PD Collection CD 1/PD Collection CD 1.iso/textual/tex/files/!preview/RCS/c/dviread

Text File | 1990-12-07 | 54.3 KB | 2,354 lines

head     1.4;
branch   ;
access   ;
symbols  ;
locks    gtoal:1.4;
comment  @ * @;


1.4
date     91.03.02.14.24.05;  author gtoal;  state Exp;
branches ;
next     1.3;

1.3
date     91.03.02.14.09.25;  author gtoal;  state Exp;
branches ;
next     1.2;

1.2
date     91.03.02.13.59.09;  author gtoal;  state Exp;
branches ;
next     1.1;

1.1
date     91.03.02.13.55.43;  author gtoal;  state Exp;
branches ;
next     ;


desc
@Initial release
@


1.4
log
@Problems with an 'extern' which wasn't (another one I'd changed after
 giving 1.0 to IAY)
@
text
@/* dviread.c --- Read dvi file; from dvitype.web.  */

#include "web2c.h"
#include <stdarg.h>

int debug = 0;

/* <unix.io.h>: Simulation of Unix open/write etc in terms of <stdio.h> */
/* version 0.01: created AM 18-oct-86. */

#ifndef __unix_io_h
#define __unix_io_h
#define __system_io
#define _iob __iob
#define FILEHANDLE int
/* note that the following macro definitions rely on the internal       */
/* details of the NorCroft C <stdio> implementation.                    */

/* flags for OPEN */
#define O_RDONLY 0
#define O_WRONLY 1
#define O_RDWRITE 2

/* generates small code per module: */
static char _open_mode[][4] = {"rb", "wb", "rb+"};
static FILE *_open_temp;
#define write(fd,buf,siz) fwrite(buf, 1, siz, &_iob[fd])
#define unixread(fd,buf,siz) fread(buf, 1, siz, &_iob[fd])
#define open(name,mode) \
  ((_open_temp = fopen(name,_open_mode[mode]))!=0 ? _open_temp - _iob : -1)
#define creat(name,prot) \
  ((_open_temp = fopen(name,"wb"))!=0 ? _open_temp - _iob : -1)
#define close(fd) fclose(&_iob[fd])
#define lseek(fd,pos,org) fseek(&_iob[fd],pos,org)
extern int _fisatty(FILE *);
#define isatty(fd) _fisatty(&_iob[fd])
#define unlink(file) remove(file)
#define getpid() 1

#endif

/* end of <unix.io.h> */
/* 9999 30 */
#define maxfonts 100
#define maxwidths 10000
#define linelength 79
#define terminallinelength 150
#define stacksize 100
#define namesize 1000
#define namelength 256
typedef schar ASCIIcode  ;
typedef file_ptr /* of  char */ textfile  ;
typedef unsigned char eightbits  ;
typedef file_ptr /* of  eightbits */ bytefile  ;
ASCIIcode xord[128]  ;
char xchr[256]  ;
bytefile dvifile  ;
bytefile tfmfile  ;
integer curloc  ;
char curname[namelength + 1], realnameoffile[namelength + 1]  ;
eightbits b0, b1, b2, b3  ;
integer fontnum[maxfonts + 1]  ;
integer fontname[maxfonts + 1]  ;
ASCIIcode names[namesize + 1]  ;
integer fontchecksum[maxfonts + 1]  ;
integer fontscaledsize[maxfonts + 1]  ;
integer fontdesignsize[maxfonts + 1]  ;
integer fontspace[maxfonts + 1]  ;
integer fontbc[maxfonts + 1]  ;
integer fontec[maxfonts + 1]  ;
integer widthbase[maxfonts + 1]  ;
integer width[maxwidths + 1]  ;
integer nf  ;
integer widthptr  ;
integer inwidth[256]  ;
integer tfmchecksum  ;
integer pixelwidth[maxwidths + 1]  ;
real conv  ;
real trueconv  ;
integer numerator, denominator  ;
integer mag  ;
schar outmode  ;
integer maxpages  ;
real resolution  ;
integer newmag  ;
integer startcount[10]  ;
boolean startthere[10]  ;
schar startvals  ;
integer count[10]  ;
ASCIIcode buffer[terminallinelength + 1]  ;
integer bufptr  ;
boolean inpostamble  ;
integer textptr  ;
ASCIIcode textbuf[linelength + 1]  ;
integer h, v, w, x, y, z, hh, vv  ;
integer hstack[stacksize + 1], vstack[stacksize + 1], wstack[stacksize + 1],
xstack[stacksize + 1], ystack[stacksize + 1], zstack[stacksize + 1]  ;
integer hhstack[stacksize + 1], vvstack[stacksize + 1]  ;
integer maxv  ;
integer maxh  ;
integer maxs  ;
integer maxvsofar, maxhsofar, maxssofar  ;
integer totalpages  ;
integer pagecount  ;
integer s  ;
integer ss  ;
integer curfont  ;
boolean showing  ;
integer oldbackpointer  ;
integer newbackpointer  ;
boolean started  ;
integer postloc  ;
integer firstbackpointer  ;
integer startloc  ;
integer k, m, n, p, q  ;

char font_name[256];
int font_size;
int font_charwidth;

#include "dvitype.h"
/* External procedures for dvitype                              */
/*   Written by: H. Trickey, 2/19/83 (adapted from TeX's ext.c) */

#include <string.h>

#define TRUE    1
#define FALSE   0

integer argc;
char *fontpath;
extern char *getenv();

/*
 * setpaths is called to set up the pointer fontpath
 * as follows:  if the user's environment has a value for TEXFONTS
 * then use it;  otherwise, use defaultfontpath.
 */
setpaths()
{
        register char *envpath;

        if ((envpath = getenv("TEXFONTS")) != NULL)
            fontpath = envpath;
        else
            fontpath = TEXFONTS;
}

#define namelength 256   /* should agree with dvitype.ch */
/* extern char curname[],realnameoffile[];*/ /* these have size namelength */

/*
 *      testaccess(amode,filepath)
 *
 *  Test whether or not the file whose name is in the global curname
 *  can be opened for reading (if mode=READACCESS)
 *  or writing (if mode=WRITEACCESS).
 *
 *  The filepath argument is one of the ...FILEPATH constants defined below.
 *  If the filename given in curname does not begin with '/', we try
 *  prepending all the ':'-separated areanames in the appropriate path to the
 *  filename until access can be made, if it ever can.
 *
 *  The realnameoffile global array will contain the name that yielded an
 *  access success.
 */

#define READACCESS 4
#define WRITEACCESS 2

#define NOFILEPATH 0
#define FONTFILEPATH 3

static packrealnameoffile(char **cpp);


testaccess(amode,filepath)
int amode,filepath;
{
    register boolean ok;
    register char *p;
    char *curpathplace;
    int f;

    switch(filepath) {
        case NOFILEPATH: curpathplace = NULL; break;
        case FONTFILEPATH: curpathplace = fontpath; break;
        }
    if (curname[0]=='/')        /* file name has absolute path */
        curpathplace = NULL;
    do {
        packrealnameoffile(&curpathplace);
        if (amode==READACCESS) {
            FILE *temp;
            /* use system call "access" to see if we could read it */
            ok = FALSE;
            if ((temp = fopen(realnameoffile, "rb")) != NULL) ok = TRUE;
            if (ok) {
              fclose(temp);
            } else {
              tfatal ("(dviread) Cannot open `%s'\n", realnameoffile);
            }
        } else {
            /* WRITEACCESS: use creat to see if we could create it, but close
            the file again if we're OK, to let pc open it for real */
            f = creat(realnameoffile,0666);
            ok = (f >= 0);
            if (ok)
                (void) close(f);
            }
    } while (!ok && curpathplace != NULL);
    if (ok) {  /* pad realnameoffile with blanks, as Pascal wants */
        for (p = realnameoffile; *p != '\0'; p++)
            /* nothing: find end of string */ ;
        while (p < &(realnameoffile[namelength]))
            *p++ = ' ';
        }
    return (ok);
}

/*
 * packrealnameoffile(cpp) makes realnameoffile contain the directory at *cpp,
 * followed by '/', followed by the characters in curname up until the
 * first blank there, and finally a '\0'.  The cpp pointer is left pointing
 * at the next directory in the path.
 * But: if *cpp == NULL, then we are supposed to use curname as is.
 */
static packrealnameoffile(cpp)
    char **cpp;
{
    register char *p,*realname;

    realname = realnameoffile;
    if ((p = *cpp)!=NULL) {
        while ((*p != ',') && (*p != '\0')) {
            *realname++ = *p++;
            if (realname == &(realnameoffile[namelength-1]))
                break;
            }
        if (*p == '\0') *cpp = NULL; /* at end of path now */
        else *cpp = p+1; /* else get past ':' */
#ifndef ARM
        *realname++ = '/';  /* separate the area from the name to follow */
#endif
        }
    /* now append curname to realname... */
    p = curname + 1;
    while (*p != ' ') {
        if (realname >= &(realnameoffile[namelength-1])) {
            tfatal ("(dviread) Full file name is too long\n");
            break;
            }
        *realname++ = *p++;
        }
    *realname = '\0';
}

static char **gargv;
argv(n, buf)
int n;
char buf[];
{
    (void) sprintf(buf+1, "%s ", gargv[n]);
}


dviread_main(ac, av)
     int ac;
     char **av;
{
  argc = ac;
  gargv = av;
  main_body();
}


#define char_index      strchr


/* Open a file; don't return if error */
FILE *openf(name, mode)
char *name, *mode;
{
    FILE *result;
    char *cp;

    --name;     /* All names are indexed starting at 1 */
    cp = char_index(name, ' ');
    if (cp) *cp = '\0';
    result = fopen(name, mode);
    if (result) return(result);
    perror(name);
    exit(1);
    /*NOTREACHED*/
}

/* Print real number r in format n:m */
printreal(r, n, m)
double r;
int n,m;
{
    char fmt[50];

    (void) sprintf(fmt, "%%%d.%df", n, m);
    (void) fprintf(stderr, fmt, r);
}

/* Return true on end of line or eof of file, else false */
eoln(f)
FILE *f;
{
    register int c;

    if (feof(f)) return(1);
    c = getc(f);
    if (c != EOF)
        (void) ungetc(c, f);
    return (c == '\n' || c == EOF);
}

/* Return true on end of file, else false */
#undef eof
int eof(f)
FILE *f;
{
    register int c;

    if (feof(f)) return(1);
    c = getc(f);
    if (c != EOF)
        (void) ungetc(c, f);
    return (c == EOF);
}

integer zround(f)
double f;
{
    if (f >= 0.0) return(f + 0.5);
    return(f - 0.5);
}


static int oldhh = -1;
static int oldvv = -1;
static int draw_rule = false;


initialize () {
    integer i  ;
  setpaths () ;
  {register integer for_end; i = 0 ; for_end = 31 ; if ( i <= for_end) do
    xchr [ i ] = '?' ;
  while ( i++ < for_end ) ; }
  xchr [ 32 ] = ' ' ;
  xchr [ 33 ] = '!' ;
  xchr [ 34 ] = '"' ;
  xchr [ 35 ] = '#' ;
  xchr [ 36 ] = '$' ;
  xchr [ 37 ] = '%' ;
  xchr [ 38 ] = '&' ;
  xchr [ 39 ] = '\'' ;
  xchr [ 40 ] = '(' ;
  xchr [ 41 ] = ')' ;
  xchr [ 42 ] = '*' ;
  xchr [ 43 ] = '+' ;
  xchr [ 44 ] = ',' ;
  xchr [ 45 ] = '-' ;
  xchr [ 46 ] = '.' ;
  xchr [ 47 ] = '/' ;
  xchr [ 48 ] = '0' ;
  xchr [ 49 ] = '1' ;
  xchr [ 50 ] = '2' ;
  xchr [ 51 ] = '3' ;
  xchr [ 52 ] = '4' ;
  xchr [ 53 ] = '5' ;
  xchr [ 54 ] = '6' ;
  xchr [ 55 ] = '7' ;
  xchr [ 56 ] = '8' ;
  xchr [ 57 ] = '9' ;
  xchr [ 58 ] = ':' ;
  xchr [ 59 ] = ';' ;
  xchr [ 60 ] = '<' ;
  xchr [ 61 ] = '=' ;
  xchr [ 62 ] = '>' ;
  xchr [ 63 ] = '?' ;
  xchr [ 64 ] = '@@' ;
  xchr [ 65 ] = 'A' ;
  xchr [ 66 ] = 'B' ;
  xchr [ 67 ] = 'C' ;
  xchr [ 68 ] = 'D' ;
  xchr [ 69 ] = 'E' ;
  xchr [ 70 ] = 'F' ;
  xchr [ 71 ] = 'G' ;
  xchr [ 72 ] = 'H' ;
  xchr [ 73 ] = 'I' ;
  xchr [ 74 ] = 'J' ;
  xchr [ 75 ] = 'K' ;
  xchr [ 76 ] = 'L' ;
  xchr [ 77 ] = 'M' ;
  xchr [ 78 ] = 'N' ;
  xchr [ 79 ] = 'O' ;
  xchr [ 80 ] = 'P' ;
  xchr [ 81 ] = 'Q' ;
  xchr [ 82 ] = 'R' ;
  xchr [ 83 ] = 'S' ;
  xchr [ 84 ] = 'T' ;
  xchr [ 85 ] = 'U' ;
  xchr [ 86 ] = 'V' ;
  xchr [ 87 ] = 'W' ;
  xchr [ 88 ] = 'X' ;
  xchr [ 89 ] = 'Y' ;
  xchr [ 90 ] = 'Z' ;
  xchr [ 91 ] = '[' ;
  xchr [ 92 ] = '\\' ;
  xchr [ 93 ] = ']' ;
  xchr [ 94 ] = '^' ;
  xchr [ 95 ] = '_' ;
  xchr [ 96 ] = '`' ;
  xchr [ 97 ] = 'a' ;
  xchr [ 98 ] = 'b' ;
  xchr [ 99 ] = 'c' ;
  xchr [ 100 ] = 'd' ;
  xchr [ 101 ] = 'e' ;
  xchr [ 102 ] = 'f' ;
  xchr [ 103 ] = 'g' ;
  xchr [ 104 ] = 'h' ;
  xchr [ 105 ] = 'i' ;
  xchr [ 106 ] = 'j' ;
  xchr [ 107 ] = 'k' ;
  xchr [ 108 ] = 'l' ;
  xchr [ 109 ] = 'm' ;
  xchr [ 110 ] = 'n' ;
  xchr [ 111 ] = 'o' ;
  xchr [ 112 ] = 'p' ;
  xchr [ 113 ] = 'q' ;
  xchr [ 114 ] = 'r' ;
  xchr [ 115 ] = 's' ;
  xchr [ 116 ] = 't' ;
  xchr [ 117 ] = 'u' ;
  xchr [ 118 ] = 'v' ;
  xchr [ 119 ] = 'w' ;
  xchr [ 120 ] = 'x' ;
  xchr [ 121 ] = 'y' ;
  xchr [ 122 ] = 'z' ;
  xchr [ 123 ] = '{' ;
  xchr [ 124 ] = '|' ;
  xchr [ 125 ] = '}' ;
  xchr [ 126 ] = '~' ;
  {register integer for_end; i = 127 ; for_end = 255 ; if ( i <= for_end) do
    xchr [ i ] = '?' ;
  while ( i++ < for_end ) ; }
  {register integer for_end; i = 0 ; for_end = 127 ; if ( i <= for_end) do
    xord [ chr ( i ) ] = 32 ;
  while ( i++ < for_end ) ; }
  {register integer for_end; i = 32 ; for_end = 126 ; if ( i <= for_end) do
    xord [ xchr [ i ] ] = i ;
  while ( i++ < for_end ) ; }
  nf = 0 ;
  widthptr = 0 ;
  fontname [ 0 ] = 0 ;
  fontspace [ 0 ] = 0 ;
  outmode = 3 ;
  maxpages = 1000000L ;
  startvals = 0 ;
  startthere [ 0 ] = false ;
  inpostamble = false ;
  textptr = 0 ;
  maxv = 2147483548L ;
  maxh = 2147483548L ;
  maxs = stacksize + 1 ;
  maxvsofar = 0 ;
  maxhsofar = 0 ;
  maxssofar = 0 ;
  pagecount = 0 ;
  oldbackpointer = -1 ;
  started = false ;
}
opendvifile () {
  if ( argc != 2 ) {
    tfatal ("(dviread) %s\n", "Usage: dvitype <dvi-file>" ) ;
    uexit ( 1 ) ;
  }
  argv ( 1 , curname ) ;
  if ( testaccess ( 4 , 0 ) )
  reset ( dvifile , realnameoffile ) ;
  else {
          tfatal ("(dviread) %s\n", "DVI file not found" ) ;
    uexit ( 1 ) ;
  }
  curloc = 0 ;
}
opentfmfile () {
    if ( testaccess ( 4 , 3 ) )
  reset ( tfmfile , realnameoffile ) ;
  else {

    tfatal ("(dviread) TFM file not found (`%s')", realnameoffile) ;
    uexit ( 1 ) ;
  }
}
readtfmword () {
  read ( tfmfile , b0 ) ;
  read ( tfmfile , b1 ) ;
  read ( tfmfile , b2 ) ;
  read ( tfmfile , b3 ) ;
}
integer getbyte () {
    register integer Result; eightbits b  ;
  if ( eof ( dvifile ) ) {
    tfatal ("(dviread) End of file detected.\n");
    Result = 0 ;
  } else {

    read ( dvifile , b ) ;
    if (feof(dvifile)) tfatal ("(dviread) Last byte of file has been read.\n");
    curloc = curloc + 1 ;
    Result = b ;
  }
  return(Result) ;
}
integer signedbyte () {
    register integer Result; eightbits b  ;
  read ( dvifile , b ) ;
  curloc = curloc + 1 ;
  if ( b < 128 )
  Result = b ;
  else Result = b - 256 ;
  return(Result) ;
}
integer gettwobytes () {
    register integer Result; eightbits a, b  ;
  read ( dvifile , a ) ;
  read ( dvifile , b ) ;
  curloc = curloc + 2 ;
  Result = a * 256 + b ;
  return(Result) ;
}
integer signedpair () {
    register integer Result; eightbits a, b  ;
  read ( dvifile , a ) ;
  read ( dvifile , b ) ;
  curloc = curloc + 2 ;
  if ( a < 128 )
  Result = a * 256 + b ;
  else Result = ( a - 256 ) * 256 + b ;
  return(Result) ;
}
integer getthreebytes () {
    register integer Result; eightbits a, b, c  ;
  read ( dvifile , a ) ;
  read ( dvifile , b ) ;
  read ( dvifile , c ) ;
  curloc = curloc + 3 ;
  Result = ( a * 256 + b ) * 256 + c ;
  return(Result) ;
}
integer signedtrio () {
    register integer Result; eightbits a, b, c  ;
  read ( dvifile , a ) ;
  read ( dvifile , b ) ;
  read ( dvifile , c ) ;
  curloc = curloc + 3 ;
  if ( a < 128 )
  Result = ( a * 256 + b ) * 256 + c ;
  else Result = ( ( a - 256 ) * 256 + b ) * 256 + c ;
  return(Result) ;
}
integer signedquad () {
    register integer Result; eightbits a, b, c, d  ;
  read ( dvifile , a ) ;
  read ( dvifile , b ) ;
  read ( dvifile , c ) ;
  read ( dvifile , d ) ;
  curloc = curloc + 4 ;
  a = a&255; b = b&255; c = c&255; d = d&255;
  Result = (a<<24) | (b<<16) | (c<<8) | d;
  return(Result) ;
}
integer dvilength () {
    register integer Result; zfseek ( dvifile , 0 , 2 ) ;
  Result = ftell ( dvifile ) ;
  return(Result) ;
}
zmovetobyte ( n )
integer n ;
{zfseek ( dvifile , n , 0 ) ;
}
zprintfont ( f )
integer f ;
{integer k  ;
static char fname[256];
char *dest = &fname[0];
  if ( f == nf )
  (void) Fputs( stderr ,  "UNDEFINED!" ) ;
  else {

    {register integer for_end; k = fontname [ f ] ; for_end = fontname [ f +
    1 ] - 1 ; if ( k <= for_end) do
      (void) putc( (*dest++ = xchr [ names [ k ] ]) ,  stderr );
    while ( k++ < for_end ) ; }
  }
  *dest = '\0';
  strcpy(font_name, fname);
}

setfontname ( f )
integer f ;
{integer k  ;
static char fname[256];
char *dest = &fname[0];
  if ( f == nf )
  (void) Fputs( stderr ,  "UNDEFINED!" ) ;
  else {

    {register integer for_end; k = fontname [ f ] ; for_end = fontname [ f +
    1 ] - 1 ; if ( k <= for_end) do
      *dest++ = xchr [ names [ k ] ];
    while ( k++ < for_end ) ; }
  }
  *dest = '\0';
  strcpy(font_name, fname);
}

boolean zinTFM ( z )
integer z ;
{/* 9997 9998 9999 */ register boolean Result; integer k  ;
  integer lh  ;
  integer nw  ;
  integer wp  ;
  integer alpha, beta  ;
  readtfmword () ;
  lh = b2 * 256 + b3 ;
  readtfmword () ;
  fontbc [ nf ] = b0 * 256 + b1 ;
  fontec [ nf ] = b2 * 256 + b3 ;
  if ( fontec [ nf ] < fontbc [ nf ] )
  fontbc [ nf ] = fontec [ nf ] + 1 ;
  if ( widthptr + fontec [ nf ] - fontbc [ nf ] + 1 > maxwidths )
  {
    tfatal ("(dviread) Internal error: width table overflow");
    goto lab9998 ;
  }
  wp = widthptr + fontec [ nf ] - fontbc [ nf ] + 1 ;
  readtfmword () ;
  nw = b0 * 256 + b1 ;
  if ( ( nw == 0 ) || ( nw > 256 ) )
  goto lab9997 ;
  {register integer for_end; k = 1 ; for_end = 3 + lh ; if ( k <= for_end) do
    {
      if ( eof ( tfmfile ) )
      goto lab9997 ;
      readtfmword () ;
      if ( k == 4 )
      if ( b0 < 128 )
      tfmchecksum = ( ( b0 * 256 + b1 ) * 256 + b2 ) * 256 + b3 ;
      else tfmchecksum = ( ( ( b0 - 256 ) * 256 + b1 ) * 256 + b2 ) * 256 + b3
      ;
    }
  while ( k++ < for_end ) ; }
  if ( wp > 0 )
  {register integer for_end; k = widthptr ; for_end = wp - 1 ; if ( k <=
  for_end) do
    {
      readtfmword () ;
      if ( b0 > nw )
      goto lab9997 ;
      width [ k ] = b0 ;
    }
  while ( k++ < for_end ) ; }
  {
    alpha = 16 * z ;
    beta = 16 ;
    while ( z >= 8388608L ) {

      z = z / 2 ;
      beta = beta / 2 ;
    }
  }
  {register integer for_end; k = 0 ; for_end = nw - 1 ; if ( k <= for_end) do
    {
      readtfmword () ;
      inwidth [ k ] = ( ( ( ( ( b3 * z ) / 256 ) + ( b2 * z ) ) / 256 ) + ( b1
      * z ) ) / beta ;
      if ( b0 > 0 )
      if ( b0 < 255 )
      goto lab9997 ;
      else inwidth [ k ] = inwidth [ k ] - alpha ;
    }
  while ( k++ < for_end ) ; }
  if ( inwidth [ 0 ] != 0 )
  goto lab9997 ;
  widthbase [ nf ] = widthptr - fontbc [ nf ] ;
  if ( wp > 0 )
  {register integer for_end; k = widthptr ; for_end = wp - 1 ; if ( k <=
  for_end) do
    if ( width [ k ] == 0 )
    {
      width [ k ] = 2147483647L ;
      pixelwidth [ k ] = 0 ;
    }
    else {

      width [ k ] = inwidth [ width [ k ] ] ;
      pixelwidth [ k ] = round ( conv * ( width [ k ] ) ) ;
    }
  while ( k++ < for_end ) ; }
  widthptr = wp ;
  Result = true ;
  goto lab9999 ;
  lab9997: tfatal ("(dviread) TFM file is bad" ) ;
  lab9998: Result = false ;
  lab9999: ;
  fclose ( tfmfile ); /* gt */
  return(Result) ;
}
boolean startmatch () {
    register boolean Result; schar k  ;
  boolean match  ;
  match = true ;
  {register integer for_end; k = 0 ; for_end = startvals ; if ( k <= for_end)
  do
    if ( startthere [ k ] && ( startcount [ k ] != count [ k ] ) )
    match = false ;
  while ( k++ < for_end ) ; }
  Result = match ;
  return(Result) ;
}
inputln () {
    integer k  ;
  flush ( stderr ) ;
  if ( eoln ( stdin ) )
  readln ( stdin ) ;
  k = 0 ;
  while ( ( k < terminallinelength ) && ! eoln ( stdin ) ) {

    buffer [ k ] = xord [ getc ( stdin ) ] ;
    k = k + 1 ;
  }
  buffer [ k ] = 32 ;
}
integer getinteger () {
    register integer Result; integer x  ;
  boolean negative  ;
  if ( buffer [ bufptr ] == 45 )
  {
    negative = true ;
    bufptr = bufptr + 1 ;
  }
  else negative = false ;
  x = 0 ;
  while ( ( buffer [ bufptr ] >= 48 ) && ( buffer [ bufptr ] <= 57 ) ) {

    x = 10 * x + buffer [ bufptr ] - 48 ;
    bufptr = bufptr + 1 ;
  }
  if ( negative )
  Result = - (integer) x ;
  else Result = x ;
  return(Result) ;
}
dialog () {
    /* 1 2 3 4 5 */ integer k  ;
  lab1:
  outmode = 2 ;
  lab2:
  startvals = 0 ;
  lab3:
  maxpages = 1000000L ;
  lab4:
  resolution = 72000.0 ;
  lab5:
  newmag = 0 ;

}
zdefinefont ( e )
integer e ;
{integer f  ;
  integer p  ;
  integer n  ;
  integer c, q, d  ;
  integer r  ;
  integer j, k  ;
  boolean mismatch  ;
  if ( nf == maxfonts )
  {
    tfatal ("(dviread) Too many fonts in dvi file");
    uexit ( 1 ) ;
  }
  fontnum [ nf ] = e ;
  f = 0 ;
  while ( fontnum [ f ] != e ) f = f + 1 ;
  c = signedquad () ;
  fontchecksum [ nf ] = c ;
  q = signedquad () ;
  fontscaledsize [ nf ] = q ;
  d = signedquad () ;
  fontdesignsize [ nf ] = d ;
  p = getbyte () ;
  n = getbyte () ;
  if ( fontname [ nf ] + n + p > namesize )
  {
    tfatal ("(dviread) name capacity exceeded");
    uexit ( 1 ) ;
  }
  fontname [ nf + 1 ] = fontname [ nf ] + n + p ;
  if ( n + p == 0 )
  (void) Fputs( stderr ,  "null font name!" ) ;
  else {
      register integer for_end; k = fontname [ nf ] ; for_end = fontname [
  nf + 1 ] - 1 ; if ( k <= for_end) do
    names [ k ] = getbyte () ;
  while ( k++ < for_end ) ; }
  nf = nf + 1 ;
  setfontname(nf-1);
  nf = nf - 1 ;
  if ( ( ( outmode == 3 ) && inpostamble ) || ( ( outmode < 3 ) && !
  inpostamble ) )
  {
    if ( f < nf )
    tfatal ("(dviread) bad dvi file (repeated font def)");
  }
  else {

    if ( f == nf )
    tfatal ("(dviread) bad dvi file (fontsel before fontdef)");
  }
  if ( f == nf )
  {
    {register integer for_end; k = 1 ; for_end = namelength ; if ( k <=
    for_end) do
      curname [ k ] = ' ' ;
    while ( k++ < for_end ) ; }
    r = 0 ;
    {register integer for_end; k = fontname [ nf ] ; for_end = fontname [ nf
    + 1 ] - 1 ; if ( k <= for_end) do
      {
        r = r + 1 ;
        if ( r + 4 > namelength )
        {
          tfatal ("(dviread) capacity exceeded (font name too long)");
          uexit ( 1 ) ;
        }
        curname [ r ] = xchr [ names [ k ] ] ;
      }
    while ( k++ < for_end ) ; }
    curname [ r + 1 ] = '.' ;
    curname [ r + 2 ] = 't' ;
    curname [ r + 3 ] = 'f' ;
    curname [ r + 4 ] = 'm' ;
    opentfmfile () ;
    if ( eof ( tfmfile ) )
    (void) Fputs( stderr ,  "---not loaded, TFM file can't be opened!" ) ;
    else {

      if ( ( q <= 0 ) || ( q >= 134217728L ) )
      tfatal ("(dviread) bad dvi file (scale)");
      else if ( ( d <= 0 ) || ( d >= 134217728L ) )
      tfatal ("(dviread) bad tfm file (bad design size)");
      else if ( inTFM ( q ) )
      {
        fontspace [ nf ] = q / 6 ;
        if ( ( c != 0 ) && ( tfmchecksum != 0 ) && ( c != tfmchecksum ) )
        {
          fatal ("(dviread) WARNING: tfm checksum does not match");
        }
        d = round ( ( 100.0 * conv * q ) / ((double) ( trueconv * d ) ) ) ;
        font_size = q; /*WIMP*/
        nf = nf + 1 ;
        fontspace [ nf ] = 0 ;
      }
    }
  }
  else {

    if ( fontchecksum [ f ] != c )
    tfatal ("(dviread) inconsistency (check sum doesn't match previous definition)");
    if ( fontscaledsize [ f ] != q )
    tfatal ("(dviread) inconsistency (scaled size doesn't match previous definition)");
    if ( fontdesignsize [ f ] != d )
    tfatal ("(dviread) inconsistency (design size doesn't match previous definition)");
    j = fontname [ f ] ;
    k = fontname [ nf ] ;
    mismatch = false ;
    while ( j < fontname [ f + 1 ] ) {

      if ( names [ j ] != names [ k ] )
      mismatch = true ;
      j = j + 1 ;
      k = k + 1 ;
    }
    if ( k != fontname [ nf + 1 ] )
    mismatch = true ;
    if ( mismatch )
    tfatal ("(dviread) inconsistency (font name doesn't match previous definition)");
  }
}
flushtext () {
integer k;
  if ( textptr > 0 ) {
    if ( outmode > 0 ) {
      register integer for_end;
       k = 1 ;
       if (xchr [ textbuf [ k ] ] == ' ') k++; /****** FUDGE!!! ******/
       for_end = textptr ;
       if ( k <= for_end) {
         char text[256]; char *textp = &text[0];
         do {
           *textp++ = xchr [ textbuf [ k ] ];
         } while ( k++ < for_end );
         *textp = '\0';
         DRAW_text(oldhh, oldvv, hh+font_charwidth, vv, text);  /*WIMPHOOK*/
         oldhh = -1; oldvv = -1;
       }
    }
    textptr = 0 ;
  }
}
zouttext ( c )
ASCIIcode c ;
{if ( textptr == linelength - 2 )
  flushtext () ;
  textptr = textptr + 1 ;
  textbuf [ textptr ] = c ;
}
integer zfirstpar ( o )
eightbits o ;
{register integer Result; switch ( o )
  {case 0 :
  case 1 :
  case 2 :
  case 3 :
  case 4 :
  case 5 :
  case 6 :
  case 7 :
  case 8 :
  case 9 :
  case 10 :
  case 11 :
  case 12 :
  case 13 :
  case 14 :
  case 15 :
  case 16 :
  case 17 :
  case 18 :
  case 19 :
  case 20 :
  case 21 :
  case 22 :
  case 23 :
  case 24 :
  case 25 :
  case 26 :
  case 27 :
  case 28 :
  case 29 :
  case 30 :
  case 31 :
  case 32 :
  case 33 :
  case 34 :
  case 35 :
  case 36 :
  case 37 :
  case 38 :
  case 39 :
  case 40 :
  case 41 :
  case 42 :
  case 43 :
  case 44 :
  case 45 :
  case 46 :
  case 47 :
  case 48 :
  case 49 :
  case 50 :
  case 51 :
  case 52 :
  case 53 :
  case 54 :
  case 55 :
  case 56 :
  case 57 :
  case 58 :
  case 59 :
  case 60 :
  case 61 :
  case 62 :
  case 63 :
  case 64 :
  case 65 :
  case 66 :
  case 67 :
  case 68 :
  case 69 :
  case 70 :
  case 71 :
  case 72 :
  case 73 :
  case 74 :
  case 75 :
  case 76 :
  case 77 :
  case 78 :
  case 79 :
  case 80 :
  case 81 :
  case 82 :
  case 83 :
  case 84 :
  case 85 :
  case 86 :
  case 87 :
  case 88 :
  case 89 :
  case 90 :
  case 91 :
  case 92 :
  case 93 :
  case 94 :
  case 95 :
  case 96 :
  case 97 :
  case 98 :
  case 99 :
  case 100 :
  case 101 :
  case 102 :
  case 103 :
  case 104 :
  case 105 :
  case 106 :
  case 107 :
  case 108 :
  case 109 :
  case 110 :
  case 111 :
  case 112 :
  case 113 :
  case 114 :
  case 115 :
  case 116 :
  case 117 :
  case 118 :
  case 119 :
  case 120 :
  case 121 :
  case 122 :
  case 123 :
  case 124 :
  case 125 :
  case 126 :
  case 127 :
    Result = o - 0 ;
    break ;
  case 128 :
  case 133 :
  case 235 :
  case 239 :
  case 243 :
    Result = getbyte () ;
    break ;
  case 129 :
  case 134 :
  case 236 :
  case 240 :
  case 244 :
    Result = gettwobytes () ;
    break ;
  case 130 :
  case 135 :
  case 237 :
  case 241 :
  case 245 :
    Result = getthreebytes () ;
    break ;
  case 143 :
  case 148 :
  case 153 :
  case 157 :
  case 162 :
  case 167 :
    Result = signedbyte () ;
    break ;
  case 144 :
  case 149 :
  case 154 :
  case 158 :
  case 163 :
  case 168 :
    Result = signedpair () ;
    break ;
  case 145 :
  case 150 :
  case 155 :
  case 159 :
  case 164 :
  case 169 :
    Result = signedtrio () ;
    break ;
  case 131 :
  case 132 :
  case 136 :
  case 137 :
  case 146 :
  case 151 :
  case 156 :
  case 160 :
  case 165 :
  case 170 :
  case 238 :
  case 242 :
  case 246 :
    Result = signedquad () ;
    break ;
  case 138 :
  case 139 :
  case 140 :
  case 141 :
  case 142 :
  case 247 :
  case 248 :
  case 249 :
  case 250 :
  case 251 :
  case 252 :
  case 253 :
  case 254 :
  case 255 :
    Result = 0 ;
    break ;
  case 147 :
    Result = w ;
    break ;
  case 152 :
    Result = x ;
    break ;
  case 161 :
    Result = y ;
    break ;
  case 166 :
    Result = z ;
    break ;
  case 171 :
  case 172 :
  case 173 :
  case 174 :
  case 175 :
  case 176 :
  case 177 :
  case 178 :
  case 179 :
  case 180 :
  case 181 :
  case 182 :
  case 183 :
  case 184 :
  case 185 :
  case 186 :
  case 187 :
  case 188 :
  case 189 :
  case 190 :
  case 191 :
  case 192 :
  case 193 :
  case 194 :
  case 195 :
  case 196 :
  case 197 :
  case 198 :
  case 199 :
  case 200 :
  case 201 :
  case 202 :
  case 203 :
  case 204 :
  case 205 :
  case 206 :
  case 207 :
  case 208 :
  case 209 :
  case 210 :
  case 211 :
  case 212 :
  case 213 :
  case 214 :
  case 215 :
  case 216 :
  case 217 :
  case 218 :
  case 219 :
  case 220 :
  case 221 :
  case 222 :
  case 223 :
  case 224 :
  case 225 :
  case 226 :
  case 227 :
  case 228 :
  case 229 :
  case 230 :
  case 231 :
  case 232 :
  case 233 :
  case 234 :
    Result = o - 171 ;
    break ;
  }
  return(Result) ;
}
integer zrulepixels ( x )
integer x ;
{register integer Result; integer n  ;
  n = trunc ( conv * x ) ;
  if ( n < conv * x )
  Result = n + 1 ;
  else Result = n ;
  return(Result) ;
}
boolean zspecialcases ( o , p , a )
eightbits o ;
integer p , a ;
{/* 46 44 30 9998 */ register boolean Result; integer q  ;
  integer k  ;
  boolean badchar  ;
  boolean pure  ;
  integer vvv  ;
  pure = true ;
  switch ( o )
  {case 157 :
  case 158 :
  case 159 :
  case 160 :
    {
      if ( abs ( p ) >= 5 * fontspace [ curfont ] )
      vv = round ( conv * ( v + p ) ) ;
      else vv = vv + round ( conv * ( p ) ) ;
      if ( outmode > 0 )
      {
        flushtext () ;
        showing = true ;
      }
      goto lab44 ;
    }
    break ;
  case 161 :
  case 162 :
  case 163 :
  case 164 :
  case 165 :
    {
      y = p ;
      if ( abs ( p ) >= 5 * fontspace [ curfont ] )
      vv = round ( conv * ( v + p ) ) ;
      else vv = vv + round ( conv * ( p ) ) ;
      if ( outmode > 0 )
      {
        flushtext () ;
        showing = true ;
      }
      goto lab44 ;
    }
    break ;
  case 166 :
  case 167 :
  case 168 :
  case 169 :
  case 170 :
    {
      z = p ;
      if ( abs ( p ) >= 5 * fontspace [ curfont ] )
      vv = round ( conv * ( v + p ) ) ;
      else vv = vv + round ( conv * ( p ) ) ;
      if ( outmode > 0 )
      {
        flushtext () ;
        showing = true ;
      }
      goto lab44 ;
    }
    break ;
  case 171 :
  case 172 :
  case 173 :
  case 174 :
  case 175 :
  case 176 :
  case 177 :
  case 178 :
  case 179 :
  case 180 :
  case 181 :
  case 182 :
  case 183 :
  case 184 :
  case 185 :
  case 186 :
  case 187 :
  case 188 :
  case 189 :
  case 190 :
  case 191 :
  case 192 :
  case 193 :
  case 194 :
  case 195 :
  case 196 :
  case 197 :
  case 198 :
  case 199 :
  case 200 :
  case 201 :
  case 202 :
  case 203 :
  case 204 :
  case 205 :
  case 206 :
  case 207 :
  case 208 :
  case 209 :
  case 210 :
  case 211 :
  case 212 :
  case 213 :
  case 214 :
  case 215 :
  case 216 :
  case 217 :
  case 218 :
  case 219 :
  case 220 :
  case 221 :
  case 222 :
  case 223 :
  case 224 :
  case 225 :
  case 226 :
  case 227 :
  case 228 :
  case 229 :
  case 230 :
  case 231 :
  case 232 :
  case 233 :
  case 234 :
    {
      if ( outmode > 0 )
      {
        flushtext () ;
        showing = true ;
        DRAW_selfont(p);  /*WIMPHOOK*/
      }
      goto lab46 ;
    }
    break ;
  case 235 :
  case 236 :
  case 237 :
  case 238 :
    {
      if ( outmode > 0 )
      {
        flushtext () ;
        showing = true ;
        DRAW_selfont(p);  /*WIMPHOOK*/
      }
      goto lab46 ;
    }
    break ;
  case 243 :
  case 244 :
  case 245 :
  case 246 :
    {
      if ( outmode > 0 )
      {
        flushtext () ;
        showing = true ;
      }
      definefont ( p ) ;
      DRAW_deffont(p, font_name, font_size>>12, mag);  /*WIMPHOOK*/
      goto lab30 ;
    }
    break ;
  case 239 :
  case 240 :
  case 241 :
  case 242 :
    {
      if ( outmode > 0 )
      {
        flushtext () ;
        showing = true ;
        /* We regressed a version since IAY was working from 1.0 and
           we were at 1.1 -- so let's redo this 'fix' */
        /*tfatal ("BARF %ld%s%s",  (long)a , ": " , "xxx '" ) ; */
      }
      badchar = false ;
      if ( p < 0 )
      if ( ! showing )
      {
        flushtext () ;
        showing = true ;
        tfatal ("(dviread) bad dvi file (string of negative length)");
      }
      else
      tfatal ("(dviread) bad dvi file (string of negative length)");
      {register integer for_end; k = 1 ; for_end = p ; if ( k <= for_end) do
        {
          q = getbyte () ;
          if ( ( q < 32 ) || ( q > 126 ) )
          badchar = true ;
          if ( showing )
          (void) putc( xchr [ q ] ,  stderr );
        }
      while ( k++ < for_end ) ; }
      if ( showing )
      (void) putc( '\'' ,  stderr );
      if ( badchar )
      if ( ! showing )
      {
        flushtext () ;
        showing = true ;
        tfatal ("(dviread) bad dvi file (non-ASCII character in xxx command)");
      }
      else
      tfatal ("(dviread) bad dvi file (non-ASCII character in xxx command)");
      goto lab30 ;
    }
    break ;
  case 247 :
    {
      if ( ! showing )
      {
        flushtext () ;
        showing = true ;
        tfatal ("(dviread) bad dvi file (preamble command within a page)");
      }
      else
      tfatal ("(dviread) bad dvi file (preamble command within a page)");
      goto lab9998 ;
    }
    break ;
  case 248 :
  case 249 :
    {
      if ( ! showing )
      {
        flushtext () ;
        showing = true ;
        tfatal ("(dviread) bad dvi file (postamble command within a page)");
      }
      else
        tfatal ("(dviread) bad dvi file (postamble command within a page)");
      goto lab9998 ;
    }
    break ;
    default:
    {
      if ( ! showing )
      {
        flushtext () ;
        showing = true ;
        tfatal ("(dviread) bad dfi file (undefined command)");
      }
      else
        tfatal ("(dviread) bad dfi file (undefined command)");
      goto lab30 ;
    }
    break ;
  }
  lab44: if ( ( v > 0 ) && ( p > 0 ) )
  if ( v > 2147483647L - p )
  {
    if ( ! showing )
    {
      flushtext () ;
      showing = true ;
      fatal ("(dviread) WARNING: arithmetic overflow! parameter changed from %d to %d", p, 2147483647L - v );
    }
    else
      fatal ("(dviread) WARNING: arithmetic overflow! parameter changed from %d to %d", p, 2147483647L - v );
    p = 2147483647L - v ;
  }
  if ( ( v < 0 ) && ( p < 0 ) )
  if ( - (integer) v > p + 2147483647L )
  {
    if ( ! showing )
    {
      flushtext () ;
      showing = true ;
      fatal ("(dviread) WARNING: arithmetic overflow! parameter changed from %d to %d", p, (int) (-v - 2147483647L));
    }
    else
      fatal ("(dviread) WARNING: arithmetic overflow! parameter changed from %d to %d", p, (int) (-v - 2147483647L));
    p = ( - (integer) v ) - 2147483647L ;
  }
  vvv = round ( conv * ( v + p ) ) ;
  if ( abs ( vvv - vv ) > 2 )
  if ( vvv > vv )
  vv = vvv - 2 ;
  else vv = vvv + 2 ;
  v = v + p ;
  if ( abs ( v ) > maxvsofar )
  {
    if ( abs ( v ) > maxv + 99 )
    {
      if ( ! showing )
      {
        flushtext () ;
        showing = true ;
/*
        tfatal ("%ld%s%s%ld%c",  (long)a , ": " , "warning: |v|>" , (long)maxv , '!' ) ;
*/
      }
      else
/*
      tfatal ("%c%s%ld%c",  ' ' , "warning: |v|>" , (long)maxv , '!' ) ;
*/
      maxv = abs ( v ) ;
    }
    maxvsofar = abs ( v ) ;
  }
  goto lab30 ;
  lab46: fontnum [ nf ] = p ;
  curfont = 0 ;
  while ( fontnum [ curfont ] != p ) curfont = curfont + 1 ;
  goto lab30 ;
  lab9998: pure = false ;
  lab30: Result = pure ;
  return(Result) ;
}

boolean dopage () {
    /* 41 42 43 45 30 9998 9999 */ register boolean Result;
  eightbits o  ;
  integer p, q  ;
  integer a  ;
  integer hhh  ;
  curfont = nf ;
  s = 0 ;
  h = 0 ;
  v = 0 ;
  w = 0 ;
  x = 0 ;
  y = 0 ;
  z = 0 ;
  hh = 0 ;
  vv = 0 ;
  DRAW_startpage();  /*WIMPHOOK*/
  while ( true ) {

    a = curloc ;
    showing = false ;
    o = getbyte () ;
    p = firstpar ( o ) ;
    if ( eof ( dvifile ) )
    {
      tfatal ("(dviread) bad dvi file (the file ended prematurely)");
      uexit ( 1 ) ;
    }
    if ( o < 128 )
    {
      if ( ( o > 32 ) && ( o <= 126 ) )
      {
        outtext ( p ) ;
        if ( outmode >= 2 )
        {
          showing = true ;
          font_charwidth = pixelwidth [ widthbase [ curfont ] + p ];
          if ((oldhh == -1) && (oldvv == -1)) {
            oldhh = hh; oldvv = vv;  /* Note start of rectangle */ /*WIMP*/
          }
        }
      }
      else if ( outmode > 0 )
      {
        flushtext () ;
        showing = true ;
         DRAW_char(hh, vv, p);  /*WIMPHOOK*/
      }
      goto lab41 ;
    }
    else switch ( o )
    {case 128 :
    case 129 :
    case 130 :
    case 131 :
      {
        if ( outmode > 0 )
        {
          flushtext () ;
          showing = true ;
/*
          tfatal ("%ld%s%s%ld%c%ld",  (long)a , ": " , "set" , (long)o - 127 , ' ' , (long)p ) ;
*/
        }
        goto lab41 ;
      }
      break ;
    case 133 :
    case 134 :
    case 135 :
    case 136 :
      {
        if ( outmode > 0 )
        {
          flushtext () ;
          showing = true ;
/*
          tfatal ("%ld%s%s%ld%c%ld",  (long)a , ": " , "put" , (long)o - 132 , ' ' , (long)p ) ;
*/
        }
        goto lab41 ;
      }
      break ;
    case 132 :
      {
        if ( outmode > 0 )
        {
          flushtext () ;
          showing = true ;
        }
        draw_rule = true; /*WIMP*/
        goto lab42 ;
      }
      break ;
    case 137 :
      {
        if ( outmode > 0 )
        {
          flushtext () ;
          showing = true ;
        }
        draw_rule = true;/*WIMP*/
        goto lab42 ;
      }
      break ;
    case 138 :
      {
        if ( outmode >= 2 )
        {
          showing = true ;
/*
          tfatal ("%ld%s%s",  (long)a , ": " , "nop" ) ;
*/
        }
        goto lab30 ;
      }
      break ;
    case 139 :
      {
        if ( ! showing )
        {
          flushtext () ;
          showing = true ;
          tfatal ("(dviread) bad dvi file (bop occurred before eop)");
        }
        else
          tfatal ("(dviread) bad dvi file (bop occurred before eop)");
        goto lab9998 ;
      }
      break ;
    case 140 :
      {
        if ( outmode > 0 )
        {
          flushtext () ;
          showing = true ;
        }
        if ( s != 0 )
        if ( ! showing )
        {
          flushtext () ;
          showing = true ;
          tfatal ("(dviread) bad dvi file (stack not empty at end of page)");
        }
        else
          tfatal ("(dviread) bad dvi file (stack not empty at end of page)");
        Result = true ;
        DRAW_endpage(maxh/* page_width */,  maxv/* page_height */,  count/* page_counters */); /*WIMPHOOK*/
        goto lab9999 ;
      }
      break ;
    case 141 :
      {
        if ( outmode > 0 )
        {
          flushtext () ;
          showing = true ;
        }
        if ( s == maxssofar )
        {
          maxssofar = s + 1 ;
          if ( s == maxs )
          if ( ! showing )
          {
            flushtext () ;
            showing = true ;
            tfatal ("(dviread) bad dvi file (deeper than claimed in postamble)");
          }
          else
            tfatal ("(dviread) bad dvi file (deeper than claimed in postamble)");
          ;
          if ( s == stacksize )
          {
            if ( ! showing )
            {
              flushtext () ;
              showing = true ;
              tfatal ("(dviread) capacity exceeded (stack)");
            }
            else
              tfatal ("(dviread) capacity exceeded (stack)");
            goto lab9998 ;
          }
        }
        hstack [ s ] = h ;
        vstack [ s ] = v ;
        wstack [ s ] = w ;
        xstack [ s ] = x ;
        ystack [ s ] = y ;
        zstack [ s ] = z ;
        hhstack [ s ] = hh ;
        vvstack [ s ] = vv ;
        s = s + 1 ;
        ss = s - 1 ;
        goto lab45 ;
      }
      break ;
    case 142 :
      {
        if ( outmode > 0 )
        {
          flushtext () ;
          showing = true ;
        }
        if ( s == 0 )
        if ( ! showing )
        {
          flushtext () ;
          showing = true ;
          tfatal ("(dviread) bad dvi file");
        }
        else
          tfatal ("(dviread) bad dvi file");
        else {

          s = s - 1 ;
          hh = hhstack [ s ] ;
          vv = vvstack [ s ] ;
          h = hstack [ s ] ;
          v = vstack [ s ] ;
          w = wstack [ s ] ;
          x = xstack [ s ] ;
          y = ystack [ s ] ;
          z = zstack [ s ] ;
        }
        ss = s ;
        goto lab45 ;
      }
      break ;
    case 143 :
    case 144 :
    case 145 :
    case 146 :
      {
#ifdef PROPER
        if ( ( p >= fontspace [ curfont ] ) || ( p <= -4 * fontspace [ curfont
        ] ) )
        {
          outtext ( 32 ) ;
          hh = round ( conv * ( h + p ) ) ;
        }
        else
#endif
        {
          if (outmode > 0) flushtext();
          hh = hh + round ( conv * ( p ) ) ;
        }
        if ( outmode >= 2 )
        {
          showing = true ;
        }
        q = p ;
        goto lab43 ;
      }
      break ;
    case 147 :
    case 148 :
    case 149 :
    case 150 :
    case 151 :
      {
        w = p ;
#ifdef PROPER
        if ( ( p >= fontspace [ curfont ] ) || ( p <= -4 * fontspace [ curfont
        ] ) )
        {
          outtext ( 32 ) ;
          hh = round ( conv * ( h + p ) ) ;
        }
        else
#endif
        {
          if (outmode > 0) flushtext();
          hh = hh + round ( conv * ( p ) ) ;
        }
        if ( outmode >= 2 )
        {
          showing = true ;
        }
        q = p ;
        goto lab43 ;
      }
      break ;
    case 152 :
    case 153 :
    case 154 :
    case 155 :
    case 156 :
      {
        x = p ;
#ifdef PROPER
        if ( ( p >= fontspace [ curfont ] ) || ( p <= -4 * fontspace [ curfont
        ] ) )
        {
          outtext ( 32 ) ;
          hh = round ( conv * ( h + p ) ) ;
        }
        else
#endif
        {
          if (outmode > 0) flushtext();
          hh = hh + round ( conv * ( p ) ) ;
        }
        if ( outmode >= 2 )
        {
          showing = true ;
        }
        q = p ;
        goto lab43 ;
      }
      break ;
      default:
      if ( specialcases ( o , p , a ) )
      goto lab30 ;
      else goto lab9998 ;
      break ;
    }
    lab41: if ( p < 0 )
    p = 255 - ( ( -1 - p ) % 256 ) ;
    else if ( p >= 256 )
    p = p % 256 ;
    if ( ( p < fontbc [ curfont ] ) || ( p > fontec [ curfont ] ) )
    q = 2147483647L ;
    else q = width [ widthbase [ curfont ] + p ] ;
    if ( q == 2147483647L )
    {
      if ( ! showing )
      {
        flushtext () ;
        showing = true ;
        tfatal ("(dviread) bad dvi file (character invalid in font)");
      }
      else
        tfatal ("(dviread) bad dvi file (character invalid in font)");
      printfont ( curfont ) ;
      if ( curfont != nf )
      (void) putc( '!' ,  stderr );
    }
    if ( o >= 133 )
    goto lab30 ;
    if ( q == 2147483647L )
    q = 0 ;
    else hh = hh + pixelwidth [ widthbase [ curfont ] + p ] ;
    goto lab43 ;
    lab42: q = signedquad () ;
    if ( showing )
    {
      if ( ( p <= 0 ) || ( q <= 0 ) ) {
        (void) Fputs( stderr ,  " (invisible)" ) ;
      } else {
        if (draw_rule) {
          DRAW_rule(hh, vv, (long)rulepixels ( p ) ,
                            (long)rulepixels ( q ));
        }
      }
    }
    draw_rule = false;
    if ( o == 137 )
    goto lab30 ;
    hh = hh + rulepixels ( q ) ;
    goto lab43 ;
    lab43: if ( ( h > 0 ) && ( q > 0 ) )
    if ( h > 2147483647L - q )
    {
      if ( ! showing )
      {
        flushtext () ;
        showing = true ;
        tfatal ("%ld%s%s%ld%s%ld",  (long)a , ": " ,         "arithmetic overflow! parameter changed from " , (long)q , " to " ,         (long)2147483647L - h ) ;
      }
      else
      tfatal ("%c%s%ld%s%ld",  ' ' ,       "arithmetic overflow! parameter changed from " , (long)q , " to " ,       (long)2147483647L - h ) ;
      q = 2147483647L - h ;
    }
    if ( ( h < 0 ) && ( q < 0 ) )
    if ( - (integer) h > q + 2147483647L )
    {
      if ( ! showing )
      {
        flushtext () ;
        showing = true ;
        tfatal ("%ld%s%s%ld%s%ld",  (long)a , ": " ,         "arithmetic overflow! parameter changed from " , (long)q , " to " , (long)(         - (integer) h ) - 2147483647L ) ;
      }
      else
      tfatal ("%c%s%ld%s%ld",  ' ' ,       "arithmetic overflow! parameter changed from " , (long)q , " to " , (long)(       - (integer) h ) - 2147483647L ) ;
      q = ( - (integer) h ) - 2147483647L ;
    }
    hhh = round ( conv * ( h + q ) ) ;
    if ( abs ( hhh - hh ) > 2 )
    if ( hhh > hh )
    hh = hhh - 2 ;
    else hh = hhh + 2 ;
    h = h + q ;
    if ( abs ( h ) > maxhsofar )
    {
      if ( abs ( h ) > maxh + 99 )
      {
        if ( ! showing )
        {
          flushtext () ;
          showing = true ;
          tfatal ("%ld%s%s%ld%c",  (long)a , ": " , "warning: |h|>" , (long)maxh , '!' ) ;
        }
        else
        tfatal ("%c%s%ld%c",  ' ' , "warning: |h|>" , (long)maxh , '!' ) ;
        maxh = abs ( h ) ;
      }
      maxhsofar = abs ( h ) ;
    }
    goto lab30 ;
    lab45: if ( showing )
    {
    }
    goto lab30 ;
    lab30: ;
  }
  lab9998: tfatal ("%c\n",  '!' ) ;
  Result = false ;
  lab9999: ;
  return(Result) ;
}
skippages () {
    /* 9999 */ integer p  ;
  unsigned char k  ;
  integer downthedrain  ;
  showing = false ;
  while ( true ) {

    if ( eof ( dvifile ) )
    {
      tfatal ("%c%s%s%c",  ' ' , "Bad DVI file: " , "the file ended prematurely"       , '!' ) ;
      uexit ( 1 ) ;
    }
    k = getbyte () ;
    p = firstpar ( k ) ;
    switch ( k )
    {case 139 :
      {
        newbackpointer = curloc - 1 ;
        pagecount = pagecount + 1 ;
        {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end)
        do
          count [ k ] = signedquad () ;
        while ( k++ < for_end ) ; }
        if ( signedquad () != oldbackpointer )
        tfatal ("%s%ld%s%ld%c\n",  "backpointer in byte " , (long)curloc - 4 ,         " should be " , (long)oldbackpointer , '!' ) ;
        oldbackpointer = newbackpointer ;
        if ( ! started && startmatch () )
        {
          started = true ;
          goto lab9999 ;
        }
      }
      break ;
    case 132 :
    case 137 :
      downthedrain = signedquad () ;
      break ;
    case 243 :
    case 244 :
    case 245 :
    case 246 :
      {
        definefont ( p ) ;
      }
      break ;
    case 239 :
    case 240 :
    case 241 :
    case 242 :
      while ( p > 0 ) {

        downthedrain = getbyte () ;
        p = p - 1 ;
      }
      break ;
    case 248 :
      {
        inpostamble = true ;
        goto lab9999 ;
      }
      break ;
      default:
      ;
      break ;
    }
  }
  lab9999: ;
}
readpostamble () {
    integer k  ;
  integer p, q, m  ;
  showing = false ;
  postloc = curloc - 5 ;
  if ( signedquad () != numerator )
  tfatal ("%s\n",  "numerator doesn't match the preamble!" ) ;
  if ( signedquad () != denominator )
  tfatal ("%s\n",  "denominator doesn't match the preamble!" ) ;
  if ( signedquad () != mag )
  if ( newmag == 0 )
  tfatal ("%s\n",  "magnification doesn't match the preamble!" ) ;
  maxv = signedquad () ;
  maxh = signedquad () ;
  maxs = gettwobytes () ;
  totalpages = gettwobytes () ;
  if ( outmode < 3 )
  {
    if ( maxv + 99 < maxvsofar )
    tfatal ("%s%ld\n",  "warning: observed maxv was " , (long)maxvsofar ) ;
    if ( maxh + 99 < maxhsofar )
    if (debug) fprintf( stderr , "%s%ld\n",  "warning: observed maxh was " , (long)maxhsofar ) ;
    if ( maxs < maxssofar )
    tfatal ("%s%ld\n",  "warning: observed maxstackdepth was " , (long)maxssofar )
    ;
    if ( pagecount != totalpages )
    tfatal ("%s%ld%s%ld%c\n",  "there are really " , (long)pagecount , " pages, not " ,     (long)totalpages , '!' ) ;
  }
  do {
      k = getbyte () ;
    if ( ( k >= 243 ) && ( k < 247 ) )
    {
      p = firstpar ( k ) ;
      definefont ( p ) ;
      k = 138 ;
    }
  } while ( ! ( k != 138 ) ) ;
  if ( k != 249 )
  tfatal ("%s%ld%s\n",  "byte " , (long)curloc - 1 , " is not postpost!" ) ;
  q = signedquad () ;
  if ( q != postloc )
  tfatal ("%s%ld%c\n",  "bad postamble pointer in byte " , (long)curloc - 4 , '!' ) ;
  m = getbyte () ;
  if ( m != 2 )
  tfatal ("%s%ld%s%ld%c\n",  "identification in byte " , (long)curloc - 1 , " should be "   , (long)2 , '!' ) ;
  k = curloc ;
  m = 223 ;
  while ( ( m == 223 ) && ! eof ( dvifile ) ) m = getbyte () ;
  if ( ! eof ( dvifile ) )
  {
    tfatal ("%c%s%s%ld%s%c",  ' ' , "Bad DVI file: " , "signature in byte " , (long)curloc     - 1 , " should be 223" , '!' ) ;
    uexit ( 1 ) ;
  }
  else if ( curloc < k + 4 )
  tfatal ("%s%ld%c\n",  "not enough signature bytes at end of file (" , (long)curloc   - k , ')' ) ;

  /* *Should* be safe now to close the dvifile */
  fclose(dvifile);

}
main_body() {

  initialize () ;
  dialog () ;
  opendvifile () ;
  p = getbyte () ;
  if ( p != 247 )
  {
    tfatal ("%c%s%s%c",  ' ' , "Bad DVI file: " ,     "First byte isn't start of preamble!" , '!' ) ;
    uexit ( 1 ) ;
  }
  p = getbyte () ;
  if ( p != 2 )
  tfatal ("%s%ld%c\n",  "identification in byte 1 should be " , (long)2 , '!' ) ;
  numerator = signedquad () ;
  denominator = signedquad () ;
  if ( numerator <= 0 )
  {
    tfatal ("%c%s%s%ld%c",  ' ' , "Bad DVI file: " , "numerator is " , (long)numerator ,     '!' ) ;
    uexit ( 1 ) ;
  }
  if ( denominator <= 0 )
  {
    tfatal ("%c%s%s%ld%c",  ' ' , "Bad DVI file: " , "denominator is " ,     (long)denominator , '!' ) ;
    uexit ( 1 ) ;
  }
  conv = ( numerator / ((double) 254000.0 ) ) * ( resolution / ((double)
  denominator ) ) ;
  mag = signedquad () ;
  if ( newmag > 0 )
  mag = newmag ;
  else if ( mag <= 0 )
  {
    tfatal ("%c%s%s%ld%c",  ' ' , "Bad DVI file: " , "magnification is " , (long)mag ,     '!' ) ;
    uexit ( 1 ) ;
  }
  trueconv = conv ;
  conv = trueconv * ( mag / ((double) 1000.0 ) ) ;
  p = getbyte () ;
#ifndef ARM
  if ( outmode == 3 )
  {
    n = dvilength () ;
    if ( n < 53 )
    {
      (void) fprintf( stderr ,
         "%c%s%s%ld%s%c",  ' ' ,
          "Bad DVI file: " , "only " , (long)n , " bytes long"       , '!' ) ;
      uexit ( 1 ) ;
    }
    m = n - 4 ;
    do {
        if ( m == 0 )
      {
        (void) fprintf( stderr ,
           "%c%s%s%c",  ' ' , "Bad DVI file: " , "all 223s" , '!' ) ;
        uexit ( 1 ) ;
      }
      movetobyte ( m ) ;
      k = getbyte () ;
      m = m - 1 ;
    } while ( ! ( k != 223 ) ) ;
    if ( k != 2 )
    {
      tfatal ("%c%s%s%ld%c",  ' ' , "Bad DVI file: " , "ID byte is " , (long)k , '!' ) ;
      uexit ( 1 ) ;
    }
    movetobyte ( m - 3 ) ;
    q = signedquad () ;
    if ( ( q < 0 ) || ( q > m - 33 ) )
    {
      tfatal ("%c%s%s%ld%s%ld%c",  ' ' , "Bad DVI file: " , "post pointer " , (long)q ,       " at byte " , (long)m - 3 , '!' ) ;
      uexit ( 1 ) ;
    }
    movetobyte ( q ) ;
    k = getbyte () ;
    if ( k != 248 )
    {
      tfatal ("%c%s%s%ld%s%c",  ' ' , "Bad DVI file: " , "byte " , (long)q , " is not post"       , '!' ) ;
      uexit ( 1 ) ;
    }
    postloc = q ;
    firstbackpointer = signedquad () ;
    inpostamble = true ;
    readpostamble () ;


    inpostamble = false ;
    q = postloc ;
    p = firstbackpointer ;
    startloc = -1 ;
    if ( p < 0 )
    inpostamble = true ;
    else {

      do {
          if ( p > q - 46 )
        {
          tfatal ("%c%s%s%ld%s%ld%c",  ' ' , "Bad DVI file: " , "page link " , (long)p ,           " after byte " , (long)q , '!' ) ;
          uexit ( 1 ) ;
        }
        q = p ;
        movetobyte ( q ) ;
        k = getbyte () ;
        if ( k == 139 )
        pagecount = pagecount + 1 ;
        else {

          tfatal ("%c%s%s%ld%s%c",  ' ' , "Bad DVI file: " , "byte " , (long)q ,           " is not bop" , '!' ) ;
          uexit ( 1 ) ;
        }
        {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end)
        do
          count [ k ] = signedquad () ;
        while ( k++ < for_end ) ; }
        if ( startmatch () )
        startloc = q ;
        p = signedquad () ;
      } while ( ! ( p < 0 ) ) ;
      if ( startloc < 0 )
      {
        tfatal ("%c%s",  ' ' , "starting page number could not be found!" )
        ;
        uexit ( 1 ) ;
      }
      movetobyte ( startloc + 1 ) ;
      oldbackpointer = startloc ;
      {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end) do
        count [ k ] = signedquad () ;
      while ( k++ < for_end ) ; }
      p = signedquad () ;
      started = true ;
    }
    if ( pagecount != totalpages )
    tfatal ("%s%ld%s%ld%c\n",  "there are really " , (long)pagecount , " pages, not " ,     (long)totalpages , '!' ) ;
  }
  else
#endif
    skippages () ;
  if ( ! inpostamble )
  {
    while ( maxpages > 0 ) {

      maxpages = maxpages - 1 ;
      {register integer for_end; k = 0 ; for_end = startvals ;
      while ( k++ < for_end ) ; }
      if ( ! dopage () )
      {
        tfatal ("%c%s%s%c",  ' ' , "Bad DVI file: " , "page ended unexpectedly"         , '!' ) ;
        uexit ( 1 ) ;
      }
      do {
          k = getbyte () ;
        if ( ( k >= 243 ) && ( k < 247 ) )
        {
          p = firstpar ( k ) ;
          definefont ( p ) ;
          k = 138 ;
        }
      } while ( ! ( k != 138 ) ) ;
      if ( k == 248 )
      {
        inpostamble = true ;
        goto lab30 ;
      }
      if ( k != 139 )
      {
        tfatal ("%c%s%s%ld%s%c",  ' ' , "Bad DVI file: " , "byte " , (long)curloc - 1 ,         " is not bop" , '!' ) ;
        uexit ( 1 ) ;
      }
      newbackpointer = curloc - 1 ;
      pagecount = pagecount + 1 ;
      {register integer for_end; k = 0 ; for_end = 9 ; if ( k <= for_end) do
        count [ k ] = signedquad () ;
      while ( k++ < for_end ) ; }
      if ( signedquad () != oldbackpointer )
      tfatal ("%s%ld%s%ld%c\n",  "backpointer in byte " , (long)curloc - 4 , " should be "       , (long)oldbackpointer , '!' ) ;
      oldbackpointer = newbackpointer ;
    }
    lab30: ;
  }
  if ( outmode < 3 )
  {
    if ( ! inpostamble )
    skippages () ;
    if ( signedquad () != oldbackpointer )
    tfatal ("%s%ld%s%ld%c\n",  "backpointer in byte " , (long)curloc - 4 , " should be " ,     (long)oldbackpointer , '!' ) ;
    readpostamble () ;
  }
}
@


1.3
log
@Re-did fix for unrecognised 'xxx' (got lost when IAY hacked from 1.0, not 1.1)
@
text
@d150 1
a150 1
extern char curname[],realnameoffile[]; /* these have size namelength */
@


1.2
log
@IAY's upgrade
@
text
@d1398 3
a1400 1
        tfatal ("BARF %ld%s%s",  (long)a , ": " , "xxx '" ) ;
@


1.1
log
@Initial revision
@
text
@d150 1
a150 1
/* NO! -- NOT external ... extern char curname[],realnameoffile[]; /* these have size namelength */
d1398 1
a1398 1
        /*tfatal ("BARF %ld%s%s",  (long)a , ": " , "xxx '" ) ; Why was this an error, tiggr? */
@